package com.zksk.admin.controller.org;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zksk.admin.domain.org.vo.OrgRequestVo;
import com.zksk.admin.domain.org.vo.OrgVo;
import com.zksk.admin.domain.org.vo.OrgWapper;
import com.zksk.admin.service.org.OrgProductService;
import com.zksk.admin.service.org.OrgService;
import com.zksk.common.core.constant.OrgConstants;
import com.zksk.common.core.domain.R;
import com.zksk.common.core.utils.StringUtils;
import com.zksk.common.core.web.controller.BaseController;
import com.zksk.common.log.annotation.Log;
import com.zksk.common.log.enums.BusinessType;
import com.zksk.mbg.admin.domain.Org;
import com.zksk.mbg.admin.domain.OrgProduct;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Update;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 机构类 信息操作处理
 *
 * @author zksk
 */
@Slf4j
@RestController
@RequestMapping("/org")
@Api(value = "OrgController", tags = "机构相关接口")
public class OrgController extends BaseController {

    @Autowired
    private OrgService orgService;

    @Autowired
    private OrgProductService orgProductService;

    /**
     * 获取机构列表
     * @param orgRequestVo
     * @return
     */
    @Log(title = "机构列表查询", businessType = BusinessType.SELECT)
    @ApiOperation(value = "获取机构列表")
    @PostMapping("/list")
    public R<Page<OrgVo>> list(@RequestBody OrgRequestVo orgRequestVo){
        Page<OrgVo> voPage = new Page<>();
        //构建条件
        LambdaQueryWrapper<Org> wrapper = new LambdaQueryWrapper<Org>()
                .like(StringUtils.isNotBlank(orgRequestVo.getOrgName()), Org::getOrgName, orgRequestVo.getOrgName())
                .eq(StringUtils.isNotBlank(orgRequestVo.getOrgType()), Org::getOrgType, orgRequestVo.getOrgType())
                .orderByAsc(Org::getCreateTime);

        //构建分页
        Page<Org> page = orgService.page(
                new Page<>(orgRequestVo.getPageNum(), orgRequestVo.getPageSize()), wrapper);
        //实体转Vo
        BeanUtil.copyProperties(page, voPage);
        //分页数据转Vo
//        voPage.setRecords(CglibUtil.copyList(page.getRecords(), OrgVo::new));

        return R.ok(voPage);
    }

    /**
     * 获取担保公司列表数据 && 获取经济公司列表数据
     * @param orgType
     * @return
     */
    @Log(title = "获取机构列表通过机构类型", businessType = BusinessType.SELECT)
    @ApiOperation(value = "获取机构列表通过机构类型 传入参数（机构类型字典值）")
    @GetMapping("/{orgType}/list")
    public R<List<Org>> listByType(@PathVariable("orgType") String orgType){
        QueryWrapper<Org> wrapper = new QueryWrapper<Org>();
        // 如果选择为银行 提供担保公司列表
        if (orgType.equals(OrgConstants.ORG_TYPE_YH)) {
            wrapper.eq(Org.ORG_TYPE, OrgConstants.ORG_TYPE_DB);
        }else if(orgType.equals(OrgConstants.ORG_TYPE_BX)){
            wrapper.eq(Org.ORG_TYPE,OrgConstants.ORG_TYPE_JJGS);
        }else{
            return R.fail("获取列表失败");
        }
        List<Org> list = orgService.list(wrapper);
        return R.ok(list);
    }

    /**
     * 根据机构id查询机构信息
     * @param orgId
     * @return
     */
    @GetMapping(value = "/{orgId}")
    @ApiOperation(value = "根据机构id查询机构信息")
    public R<OrgVo> select(@PathVariable Long orgId) {
        OrgVo orgVo = new OrgVo();
        Org orgById = orgService.getById(orgId);
        if (orgById != null) {
            BeanUtils.copyProperties(orgById,orgVo);
            // 获取机构基本信息与关联机构产品信息
            List<OrgProduct> list = orgProductService.list(
                    new QueryWrapper<OrgProduct>().eq(OrgProduct.ORG_ID, orgId));
            orgVo.setOrgProductList(list);
            return R.ok(orgVo);
        }
        return R.fail("该机构不存在");
    }

    /**
     * 删除机构
     * @param ids
     * @return
     */
    @Log(title = "机构管理", businessType = BusinessType.DELETE)
    @DeleteMapping("/{ids}")
    @ApiOperation(value = "批量删除机构(逻辑删除)")
    public R<String> remove(@PathVariable List<Long> ids) {
        // 判断机构下是否关联产品
//        List<OrgProduct> list = orgProductService.list(
//                new QueryWrapper<OrgProduct>()
//                .in(OrgProduct.ORG_ID, ids));
//        if(list != null && list.size() > 0){
//            return R.fail("机构id【" + list.get(0).getOrgId() + "】有关联的产品，无法删除");
//        }

        List<OrgProduct> list = orgProductService.list(new QueryWrapper<OrgProduct>().in(OrgProduct.ORG_ID, ids));
        if (list!= null && list.size() > 0) {
            List<Long> orgProductIds = list.stream().map(OrgProduct::getId).collect(Collectors.toList());
            boolean flag = orgProductService.deleteOrgProductRelation(orgProductIds);
            if (flag){
                // 删除机构产品 删除
                orgProductService.removeBatchByIds(orgProductIds);
            }
        }
        // 删除机构 删除
        orgService.removeBatchByIds(ids);
        return R.ok("删除成功");
    }

    /**
     * 新增机构
     * @param vo
     * @return
     */
    @Log(title = "机构管理", businessType = BusinessType.INSERT)
    @PostMapping
    @ApiOperation(value = "新增机构")
    public R<Org> add(@Validated(Insert.class) @RequestBody OrgWapper vo) {
        // 判断机构编码是否唯一
        Org org = vo.getOrg();
//        Boolean orgCodeKeyUnique = orgService.checkOrgCodeKeyUnique(org.getOrgCode());
//        if (!orgCodeKeyUnique) {
//            return R.fail("新增机构'" + org.getOrgName() + "'失败，机构编码" + org.getOrgCode() + "已存在");
//        }
        // 机构名称唯一
        Boolean orgNameUnique = orgService.checkOrgNameUnique(org.getOrgName());
        if (!orgNameUnique){
            return R.fail("新增机构'" + org.getOrgName() + "'失败，机构名称" + org.getOrgName() + "已存在");
        }
        // 机构联系人电话是否重复
        Boolean orgContactTellUnique = orgService.checkOrgContactTellUnique(org.getContactTell());
        if (!orgContactTellUnique){
            return R.fail("保存机构'" + org.getOrgName() + "'失败，机构联系人电话已存在" + org.getContactTell() + "已存在");
        }
        // 插入
        Org insertOrg = orgService.saveOrg(vo.getOrg(), vo.getOrgProductIds());
        return R.ok(insertOrg,"保存成功");
    }

    /**
     * 更新机构
     * @param vo
     * @return
     */
    @Log(title = "机构管理", businessType = BusinessType.UPDATE)
    @PutMapping
    @ApiOperation(value = "更新机构")
    public R<Org> update(@Validated(Update.class) @RequestBody OrgWapper vo) {
        // 判断机构编码是否唯一
        Org org = vo.getOrg();
        Org byId = orgService.getById(org.getOrgId());

        if(byId == null){
            return R.fail("该机构已删除，无法进行修改");
        }
        if(byId.getContactTell() != null && !byId.getContactTell().equals(org.getContactTell())){
            Boolean orgContactTellUnique = orgService.checkOrgContactTellUnique(org.getContactTell());
            if (!orgContactTellUnique){
                return R.fail("保存机构'" + org.getOrgName() + "'失败，机构联系人电话已存在" + org.getContactTell() + "已存在");
            }
        }
        // 插入
        Org insertOrg = orgService.saveOrg(org, vo.getOrgProductIds());
        return R.ok(insertOrg,"保存成功");
    }

    /**
     * 保存机构
     * @param vo
     * @return
     */
    @Log(title = "机构管理", businessType = BusinessType.INSERT)
    @PostMapping("/save")
    @ApiOperation(value = "新增或更新机构")
    public R<Org> save(@Validated @RequestBody OrgWapper vo) {
        // 判断机构编码是否唯一
        Org org = vo.getOrg();
        if(org.getOrgId() == null || org.getOrgId() <= 0){
            // 机构编码  -- 后台按照一定编码规则生成
            Boolean orgCodeKeyUnique = orgService.checkOrgCodeKeyUnique(org.getOrgCode());
            if (!orgCodeKeyUnique) {
                return R.fail("新增机构'" + org.getOrgName() + "'失败，机构编码" + org.getOrgCode() + "已存在");
            }
            // 机构名称唯一
            Boolean orgNameUnique = orgService.checkOrgNameUnique(org.getOrgName());
            if (!orgNameUnique){
                return R.fail("新增机构'" + org.getOrgName() + "'失败，机构名称" + org.getOrgName() + "已存在");
            }
            // 机构联系人电话是否重复
            Boolean orgContactTellUnique = orgService.checkOrgContactTellUnique(org.getContactTell());
            if (!orgContactTellUnique){
                return R.fail("保存机构'" + org.getOrgName() + "'失败，机构联系人电话已存在" + org.getContactTell() + "已存在");
            }
        }else{
            Org byId = orgService.getById(org.getOrgId());
            if(byId == null){
                return R.fail("该机构已删除，无法进行修改");
            }
            if(byId.getContactTell() != null && !byId.getContactTell().equals(org.getContactTell())){
                Boolean orgContactTellUnique = orgService.checkOrgContactTellUnique(org.getContactTell());
                if (!orgContactTellUnique){
                    return R.fail("保存机构'" + org.getOrgName() + "'失败，机构联系人电话已存在" + org.getContactTell() + "已存在");
                }
            }
        }
        // 插入
        Org insertOrg = orgService.saveOrg(vo.getOrg(), vo.getOrgProductIds());
        return R.ok(insertOrg,"保存成功");
    }

    /**
     * 根据机构id查询机构信息
     * @param orgId
     * @return
     */
    @GetMapping(value = "/getOrgById")
    @ApiOperation(value = "根据机构id查询机构信息")
    public R<Org> getOrgById(@RequestParam Long orgId) {
        Org orgById = orgService.getById(orgId);
        return R.ok(orgById, "查询成功");
    }


    /**
     * 查询机构数量
     * @return
     */
    @GetMapping(value = "/nums")
    @ApiOperation(value = "查询机构数量")
    public R<Long> selectNums() {
        return R.ok(orgService.count());
    }

}
